package com.company.beauty.crypto.util;

import com.company.nuwa.common.enumration.GlobalCallbackEnum;
import com.company.nuwa.common.exception.BizException;
import lombok.SneakyThrows;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;

import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;
import java.nio.charset.StandardCharsets;
import java.security.SecureRandom;
import java.util.Base64;

/**
 * <p>AES加密解密</p>
 *
 * @author lili
 * @version 1.0: AESUtils
 * @date 2023/9/20 13:52
 */
@Slf4j
public class AESUtils {

    private static final String ENCODING = "UTF-8";

    /**
     * AES加密
     * @param content 明文
     * @return 密文
     */
    public static String encryptAES(String content, String password) {
        if (StringUtils.isEmpty(content)) {
            throw new BizException(GlobalCallbackEnum.BAD_REQUEST.getCode(), "明文不能为空！");
        }
        byte[] encryptResult = encrypt(content, password);
        String encryptResultStr = parseByte2HexStr(encryptResult);
        // BASE64位加密
        encryptResultStr = encrypto(encryptResultStr);
        return encryptResultStr;
    }

    /**
     * AES解密
     * @param encryptResultStr 密文
     * @return 明文
     */
    public static String decryptAES(String encryptResultStr, String password) {
        if (StringUtils.isEmpty(encryptResultStr)) {
            throw new BizException(GlobalCallbackEnum.BAD_REQUEST.getCode(), "密文不能为空！");
        }
        // BASE64位解密
        String decrpt = decrypto(encryptResultStr);
        byte[] decryptFrom = parseHexStr2Byte(decrpt);
        byte[] decryptResult = decrypt(decryptFrom, password);
        return new String(decryptResult);
    }

    /**
     * 加密字符串
     */
    @SneakyThrows
    private static String encrypto(String str) {
        Base64.Encoder base64encoder = Base64.getEncoder();
        String result = str;
        if (str != null && str.length() > 0) {
            byte[] encodeByte = str.getBytes(ENCODING);
            result = base64encoder.encodeToString(encodeByte);
        }
        // base64加密超过一定长度会自动换行 需要去除换行符
        return result.replaceAll("\r\n", "").replaceAll("\r", "").replaceAll("\n", "");
    }

    /**
     * 解密字符串
     */
    private static String decrypto(String str) {
        Base64.Decoder base64decoder = Base64.getDecoder();
        byte[] encodeByte = base64decoder.decode(str);
        return new String(encodeByte);
    }

    /**
     * 加密
     * @param content 需要加密的内容
     * @param password 加密密码
     * @return
     */
    @SneakyThrows
    private static byte[] encrypt(String content, String password) {
        KeyGenerator kgen = KeyGenerator.getInstance("AES");
        // 注意这句是关键，防止linux下 随机生成key。用其他方式在Windows上正常，但Linux上会有问题
        SecureRandom secureRandom = SecureRandom.getInstance("SHA1PRNG");
        secureRandom.setSeed(password.getBytes());
        kgen.init(128, secureRandom);
        // kgen.init(128, new SecureRandom(password.getBytes()));
        SecretKey secretKey = kgen.generateKey();
        byte[] enCodeFormat = secretKey.getEncoded();
        SecretKeySpec key = new SecretKeySpec(enCodeFormat, "AES");
        // 创建密码器
        Cipher cipher = Cipher.getInstance("AES");
        byte[] byteContent = content.getBytes(StandardCharsets.UTF_8);
        // 初始化
        cipher.init(Cipher.ENCRYPT_MODE, key);
        byte[] result = cipher.doFinal(byteContent);
        return result; // 加密
    }

    /**
     * 解密
     * @param content 待解密内容
     * @param password 解密密钥
     * @return
     */
    @SneakyThrows
    private static byte[] decrypt(byte[] content, String password) {
        KeyGenerator kgen = KeyGenerator.getInstance("AES");
        // 防止linux下 随机生成key
        SecureRandom secureRandom = SecureRandom.getInstance("SHA1PRNG");
        secureRandom.setSeed(password.getBytes());
        kgen.init(128, secureRandom);
        // kgen.init(128, new SecureRandom(password.getBytes()));
        SecretKey secretKey = kgen.generateKey();
        byte[] enCodeFormat = secretKey.getEncoded();
        SecretKeySpec key = new SecretKeySpec(enCodeFormat, "AES");
        // 创建密码器
        Cipher cipher = Cipher.getInstance("AES");
        // 初始化
        cipher.init(Cipher.DECRYPT_MODE, key);
        byte[] result = cipher.doFinal(content);
        // 加密
        return result;
    }

    /**
     * 将二进制转换成16进制
     * @param buf
     * @return
     */
    private static String parseByte2HexStr(byte[] buf) {
        StringBuffer sb = new StringBuffer();
        for (int i = 0; i < buf.length; i++) {
            String hex = Integer.toHexString(buf[i] & 0xFF);
            if (hex.length() == 1) {
                hex = '0' + hex;
            }
            sb.append(hex.toUpperCase());
        }
        return sb.toString();
    }

    /**
     * 将16进制转换为二进制
     * @param hexStr
     * @return
     */
    private static byte[] parseHexStr2Byte(String hexStr) {
        if (hexStr.length() < 1) {
            return null;
        }
        byte[] result = new byte[hexStr.length() / 2];
        for (int i = 0; i < hexStr.length() / 2; i++) {
            int high = Integer.parseInt(hexStr.substring(i * 2, i * 2 + 1), 16);
            int low = Integer.parseInt(hexStr.substring(i * 2 + 1, i * 2 + 2), 16);
            result[i] = (byte) (high * 16 + low);
        }
        return result;
    }

}